#include "CycLink.h"
#include <iostream>

// 构造函数
CycLink::CycLink() {
    head = nullptr; // 初始化头指针为空
    len = 0; // 初始化长度为0
}

// 析构函数
CycLink::~CycLink() {
    if (head == nullptr) return; // 如果链表为空，直接返回

    node* current = head; // 从头节点的下一个节点开始
    node* nextNode;

    // 遍历并删除所有节点
    while (current != head) {
        nextNode = current->next; // 保存下一个节点
        delete current; // 删除当前节点
        current = nextNode; // 移动到下一个节点
    }
    
    delete head; // 删除头节点
    head = nullptr; // 清空头指针
}

// 获取链表长度
int CycLink::length() const {
    return len; // 返回长度
}

// 获取指定位置的数据
int CycLink::getData(const int& location) const {
    if (location < 0 || location >= len) return -1; // 超出范围

    node* current = head; // 从头节点的下一个节点开始
    for (int i = 0; i < location; ++i) {
        current = current->next; // 遍历到指定位置
    }
    return current->value; // 返回值
}

// 插入元素
void CycLink::insert(const int& data, const int& location) {
    if (location < 0 || location > len) return; // 超出范围

    node* newNode = new node; // 创建新节点
    newNode->value = data; // 设置值

    if (len == 0) { // 插入到空链表
        head = newNode; // 新节点成为头节点
        newNode->next = head; // 循环指向自身
    } else if (location == 0) { // 插入到链表头部
        node* tail = head; // 找到尾节点
        while (tail->next != head) {
            tail = tail->next; // 找到当前链表的尾节点
        }
        tail->next = newNode; // 尾节点的next指向新节点
        newNode->next = head; // 新节点的next指向当前的头节点
        head = newNode; // 更新头节点
    } else {
        node* current = head; // 从头节点开始
        for (int i = 0; i < location - 1; ++i) {
            current = current->next; // 遍历到插入位置的前一个节点
        }
        newNode->next = current->next; // 新节点的next指向当前位置的节点
        current->next = newNode; // 当前节点的next指向新节点
    }

    len++; // 增加链表长度
}


// 删除指定位置的元素
bool CycLink::remove(const int& location) {
    if (location < 0 || location >= len) return false; // 超出范围

    if (len == 1) { // 只有一个节点的特殊处理
        delete head; // 删除唯一节点
        head = nullptr; // 更新头指针
    } else {
        node* current = head;
        for (int i = 0; i < location - 1; ++i) {
            current = current->next; // 找到要删除节点的前一个节点
        }
        node* toDelete = current->next; // 要删除的节点
        current->next = toDelete->next; // 跳过要删除的节点
        if (toDelete == head) { // 如果删除的是头节点
            head = current->next; // 更新头节点
        }
        delete toDelete; // 删除节点
    }

    len--; // 减少链表长度
    return true; // 删除成功
}

// 翻转链表
void CycLink::converse() {
    if (len <= 1) return; // 如果链表为空或只有一个节点，直接返回

    node* prev = head; // 前一个节点
    node* current = head->next; // 当前节点
    node* nextNode;

    // 遍历链表，翻转指针
    while (current != head) {
        nextNode = current->next; // 保存下一个节点
        current->next = prev; // 翻转当前节点的指针
        prev = current; // 移动前一个节点
        current = nextNode; // 移动当前节点
    }

    // 更新头节点的指针
    head->next = prev; // 新的头节点的下一个指向翻转后的第一个节点
    head = prev; // 更新头节点
}

// 拼接另一个循环链表
void CycLink::append(const CycLink& append_list) {
    if (append_list.len == 0) return; // 如果要拼接的链表为空，直接返回

    if (len == 0) { // 当前链表为空
        head = append_list.head; // 将头指针指向要拼接的链表的头
    } else {
        node* tail = head; // 找到当前链表的尾节点
        while (tail->next != head) {
            tail = tail->next;
        }
        tail->next = append_list.head->next; // 将尾节点指向要拼接链表的头节点
        tail = append_list.head; // 找到要拼接链表的尾节点
        while (tail->next != append_list.head) {
            tail = tail->next;
        }
        tail->next = head; // 尾节点指向当前链表的头节点
    }

    len += append_list.len; // 更新当前链表的长度
}
